home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Environments / Clean 1.2.4 / IOInterface / deltaMenu.icl < prev    next >
Encoding:
Modula Implementation  |  1997-04-23  |  27.5 KB  |  669 lines  |  [TEXT/3PRM]
  1. implementation module deltaMenu;
  2.  
  3. import    StdClass,StdInt, StdBool, StdMisc, StdString, StdChar;
  4. import    menuDevice;
  5.  
  6. //    Common access-rules:
  7.  
  8. MenuHandle_MacMenuHandle :: !(MenuHandle s) -> MacMenuHandle;
  9. MenuHandle_MacMenuHandle (PullDownHandle h _ _ _ _) = h;
  10.     
  11. MenuHandle_SetMacMenuHandle :: !(MenuHandle s) !MacMenuHandle -> MenuHandle s;
  12. MenuHandle_SetMacMenuHandle (PullDownHandle _ id mac_id able items) h`
  13.     =    PullDownHandle h` id mac_id able items;
  14.  
  15. MenuHandle_MenuId :: !(MenuHandle s) -> MenuId;
  16. MenuHandle_MenuId (PullDownHandle _ id _ _ _) = id;
  17.  
  18. MenuHandle_SelectState :: !(MenuHandle s) -> SelectState;
  19. MenuHandle_SelectState (PullDownHandle _ _ _ able _) = able;
  20.  
  21. MenuHandle_SetAbility :: !SelectState !(MenuHandle s) -> MenuHandle s;
  22. MenuHandle_SetAbility ability (PullDownHandle h id mId _ items)
  23.     =    PullDownHandle h id mId ability items;
  24.  
  25. MenuHandle_MenuItemId :: !(MenuHandle s) -> (!Bool, !MenuItemId);
  26. MenuHandle_MenuItemId (MenuItemHandle        id _ _)    = (True, id);
  27. MenuHandle_MenuItemId (CheckMenuItemHandle    id _ _)    = (True, id);
  28. MenuHandle_MenuItemId (SubMenuItemHandle _    id _ _)    = (True, id);
  29. MenuHandle_MenuItemId (MenuItemGroupHandle    id _)    = (True, id);
  30. MenuHandle_MenuItemId _                                = (False, 0);
  31.  
  32. MenuHandle_ShortcutKey :: !(MenuHandle s) -> Char;
  33. MenuHandle_ShortcutKey (MenuItemHandle        _ c _)    = c;
  34. MenuHandle_ShortcutKey (CheckMenuItemHandle    _ c _)    = c;
  35. MenuHandle_ShortcutKey _                            = '0';
  36.  
  37.  
  38. //    Enabling and Disabling of the MenuSystem:
  39.  
  40. EnableMenuSystem :: !(IOState s) -> IOState s;
  41. EnableMenuSystem ioState
  42.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  43.     where {
  44.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  45.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  46.         (menus1, tb1)        = EnableMenuSystem` menus tb;
  47.     };
  48.  
  49. EnableMenuSystem` :: !(DeviceSystemState s) !Toolbox -> (!DeviceSystemState s, !Toolbox);
  50. EnableMenuSystem` mSystem=:(MenuSystemState (menus, cuts, handle, systemAble)) tb
  51. |    systemAble    = (mSystem,tb);
  52.                 = (MenuSystemState (menus, cuts, handle, SystemAble), EnableTheMenuSystem menus tb);
  53.     
  54. EnableTheMenuSystem    :: ![MenuHandle s] !Toolbox -> Toolbox;
  55. EnableTheMenuSystem [menu : menus] tb
  56. |    Enabled able    = SetAbilityMenu Able (MenuHandle_MacMenuHandle menu) tb1;
  57.                     = tb1;
  58.     where {
  59.         tb1            = EnableTheMenuSystem menus tb;
  60.         able        = MenuHandle_SelectState menu;
  61.     };
  62. EnableTheMenuSystem menus tb = tb;
  63.  
  64. DisableMenuSystem :: !(IOState s) -> IOState s;
  65. DisableMenuSystem ioState
  66.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  67.     where {
  68.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  69.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  70.         (menus1, tb1)        = DisableMenuSystem` menus tb;
  71.     };
  72.  
  73. DisableMenuSystem` :: !(DeviceSystemState s) !Toolbox -> (!DeviceSystemState s,!Toolbox);
  74. DisableMenuSystem` mSystem=:(MenuSystemState (menus, cuts, handle, systemAble)) tb
  75. |    not systemAble    = (mSystem,tb);
  76.                     = (MenuSystemState (menus, cuts, handle, SystemUnable),tb1);
  77.     where {
  78.         tb1 = DisableTheMenuSystem menus tb;
  79.     };
  80.     
  81. DisableTheMenuSystem :: ![MenuHandle s] !Toolbox -> Toolbox;
  82. DisableTheMenuSystem [menu : menus] tb
  83.     =    DisableTheMenuSystem menus (SetAbilityMenu Unable (MenuHandle_MacMenuHandle menu) tb);
  84. DisableTheMenuSystem _ tb = tb;
  85.  
  86.  
  87. //    Enabling and Disabling of Menus:
  88.  
  89. EnableMenus :: ![MenuId] !(IOState s) -> IOState s;
  90. EnableMenus [] ioState = ioState;
  91. EnableMenus menuIds ioState
  92.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  93.     where {
  94.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  95.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  96.         (menus1,tb1)        = SetAbilityMenus Able menuIds menus tb;
  97.     };
  98.  
  99. DisableMenus :: ![MenuId] !(IOState s) -> IOState s;
  100. DisableMenus [] ioState = ioState;
  101. DisableMenus menuIds ioState
  102.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  103.     where {
  104.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  105.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  106.         (menus1,tb1)        = SetAbilityMenus Unable menuIds menus tb;
  107.     };
  108.  
  109. SetAbilityMenus    :: !SelectState ![MenuId] !(DeviceSystemState s) !Toolbox
  110.     ->    (!DeviceSystemState s, !Toolbox);
  111. SetAbilityMenus ability menuIds (MenuSystemState (menus, cuts, handle, systemAble)) tb
  112.     =    (MenuSystemState (menus1, cuts, handle, systemAble), tb1);
  113.     where {
  114.         (menus1,tb1) = SetAbilityMenus` ability systemAble menuIds menus tb;
  115.     };
  116.  
  117. SetAbilityMenus` :: !SelectState !Bool ![MenuId] ![MenuHandle s] !Toolbox
  118.     ->    (![MenuHandle s],!Toolbox);
  119. SetAbilityMenus` _ _ [] menus      tb = (menus,tb);
  120. SetAbilityMenus` _ _ _  menus=:[] tb = (menus,tb);
  121. SetAbilityMenus` ability systemAble menuIds [menu : menus] tb
  122. |    systemAble && contains_id
  123.     =    ([menu1    : menus1], tb2);
  124. |    contains_id
  125.     =    ([menu1    : menus1], tb1);
  126.     =     ([menu    : menus1], tb1);
  127.     where {
  128.         (contains_id, menuIds`)    = RemoveCheckInt menuIds (MenuHandle_MenuId menu);
  129.         (menus1,tb1)            = SetAbilityMenus` ability systemAble menuIds` menus tb;
  130.         tb2                        = SetAbilityMenu ability (MenuHandle_MacMenuHandle menu) tb1;
  131.         menu1                    = MenuHandle_SetAbility ability menu;
  132.     };
  133.  
  134. SetAbilityMenu :: !SelectState !MacMenuHandle !Toolbox -> Toolbox;
  135. SetAbilityMenu Able   menuH tb = EnableItem  menuH 0 tb;
  136. SetAbilityMenu Unable menuH tb = DisableItem menuH 0 tb;
  137.  
  138.  
  139. /*    Adding MenuItems to MenuItemGroups:
  140.     items in a MenuItemGroup are positioned starting from 1 and increasing by 1.
  141.     Insert/Append with a position less than 1 adds the new elements in front;
  142.     Insert/Append with a position higher than the number of items adds the new elements to
  143.     the end.
  144.     Insert an item on a position adds the item BEFORE the item on that position,
  145.     Append an item on a position adds the item AFTER  the item on that position.
  146.     Only (Check)MenuItems and MenuSeparators are added to MenuItemGroups.
  147. */
  148.  
  149. InsertMenuItems    :: !MenuItemGroupId !Int ![MenuElement s (IOState s)] !(IOState s) -> IOState s;
  150. InsertMenuItems _ _ [] ioState = ioState;
  151. InsertMenuItems groupId position newItems ioState
  152.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  153.     where {
  154.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  155.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  156.         (menus1, tb1)        = AddMenusItems groupId (Max 0 (position-1)) newItems menus tb;
  157.     };    
  158.  
  159. AppendMenuItems    :: !MenuItemGroupId !Int ![MenuElement s (IOState s)] !(IOState s) -> IOState s;
  160. AppendMenuItems _ _ [] ioState = ioState;
  161. AppendMenuItems groupId position newItems ioState
  162.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  163.     where {
  164.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  165.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  166.         (menus1, tb1)        = AddMenusItems groupId (Max 0 position) newItems menus tb;
  167.     };    
  168.  
  169. AddMenusItems :: !MenuItemGroupId !Int ![MenuElement s (IOState s)] !(DeviceSystemState s) !Toolbox
  170.     ->    (!DeviceSystemState s,!Toolbox);
  171. AddMenusItems groupId position newItems (MenuSystemState (menus, cuts, handle, systemAble)) tb
  172.     =    (MenuSystemState (menus1, cuts1, handle, systemAble), tb1);
  173.     where {
  174.         (menus1, cuts1, tb1) = AddMenusItems` groupId position newItems menus cuts tb;
  175.     };
  176.     
  177. AddMenusItems` :: !MenuItemGroupId !Int ![MenuElement s (IOState s)] ![MenuHandle s] ![Char] !Toolbox
  178.     ->    (![MenuHandle s], ![Char], !Toolbox);
  179. AddMenusItems` groupId position newItems [menu : menus] cuts tb
  180. |    hasGroup    = ([menu1 : menus ], cuts1,        tb1);
  181.                 = ([menu  : menus1], otherCuts,    tb2);
  182.     where {
  183.         (hasGroup,menu1,cuts1,tb1) = EnlargeMenuItemGroup    groupId position newItems menu  cuts tb;
  184.         (menus1, otherCuts,   tb2) = AddMenusItems`            groupId position newItems menus cuts tb1;
  185.     };
  186. AddMenusItems` _ _ _ menus cuts tb = (menus, cuts, tb);
  187.  
  188. EnlargeMenuItemGroup :: !MenuItemGroupId !Int ![MenuElement s (IOState s)]
  189.                 !(MenuHandle s) ![Char]  !Toolbox
  190.     ->    (!Bool, ! MenuHandle s, ![Char], !Toolbox);
  191. EnlargeMenuItemGroup groupId pos newItems menuH=:(PullDownHandle h id mac_id able items) cuts tb
  192. |    hasGroup    = (True,  PullDownHandle h id mac_id able items1, cuts1, tb1);
  193.                 = (False, menuH, cuts, tb1);
  194.     where {
  195.         (hasGroup,items1,cuts1,tb1) = EnlargeMenuItemGroup` groupId pos newItems h items cuts tb 1;
  196.     };
  197.  
  198. EnlargeMenuItemGroup` :: !MenuItemGroupId !Int ![MenuElement s (IOState s)] !MacMenuHandle
  199.                 ![MenuHandle s] ![Char] !Toolbox !Int
  200.     ->    (!Bool, ![MenuHandle s],![Char],!Toolbox);
  201. EnlargeMenuItemGroup` id pos newItems h [gH=:MenuItemGroupHandle gId gItems : hs] cuts tb nr
  202. |    id == gId    = (True, [MenuItemGroupHandle gId gItems1 : hs], cuts1, tb1);
  203.                 = (b,    [gH : hs1], cuts2, tb2);
  204.     where {
  205.         (gItems1,cuts1,tb1)    = EnlargeItemGroup pos newItems h gItems cuts tb nr;
  206.         (b, hs1, cuts2,tb2)    = EnlargeMenuItemGroup` id pos newItems h hs cuts tb nr1;
  207.         nr1                    = nr + Length_new gItems;
  208.     };
  209. EnlargeMenuItemGroup` id pos newItems h [subH=:SubMenuItemHandle sH sId mId items : hs] cuts tb nr
  210. |    hasGroup    = (True, [SubMenuItemHandle sH sId mId items1 : hs], cuts1, tb1);
  211.                 = (b,    [subH : hs1], cuts2, tb2);
  212.     where {
  213.         (hasGroup,items1,cuts1,tb1)    = EnlargeMenuItemGroup` id pos newItems sH items cuts tb 1;
  214.         (b, hs1, cuts2, tb2)        = EnlargeMenuItemGroup` id pos newItems h hs cuts tb1 (nr+1);
  215.     };
  216. EnlargeMenuItemGroup` id pos newItems h [handle : handles] cuts tb nr
  217.     =    (b, [handle : handles`], cuts`, tb`);
  218.     where {
  219.         (b,handles`,cuts`,tb`) = EnlargeMenuItemGroup` id pos newItems h handles cuts tb (nr+1);
  220.     };
  221. EnlargeMenuItemGroup` _ _ _ _ handles cuts tb _ = (False, handles, cuts, tb);
  222.  
  223. EnlargeItemGroup :: !Int ![MenuElement s (IOState s)] !MacMenuHandle
  224.          ![MenuHandle s] ![Char] !Toolbox !Int
  225.     ->    (![MenuHandle s],![Char],!Toolbox);
  226. EnlargeItemGroup 0 newItems h items cuts tb nr
  227.     =     EnlargeItemGroup` newItems h items cuts tb (nr-1);
  228. EnlargeItemGroup position newItems h [item : items] cuts tb nr
  229.     =    ([item : items`], cuts`, tb`);
  230.     where {
  231.         (items`, cuts`, tb`) = EnlargeItemGroup (position-1) newItems h items cuts tb (nr+1);
  232.     };
  233. EnlargeItemGroup position newItems h items cuts tb nr
  234.     =    EnlargeItemGroup` newItems h items cuts tb (nr-1);
  235.  
  236. EnlargeItemGroup` :: ![MenuElement s (IOState s)] !MacMenuHandle
  237.          ![MenuHandle s] ![Char] !Toolbox !Int
  238.     ->    (![MenuHandle s],![Char],!Toolbox);
  239. EnlargeItemGroup` [newItem : newItems] h items cuts tb nr
  240. |    MenuElementIsGroupItem newItem    = ([itemH : items1], cuts2, tb4);
  241.                                     = (            items1,  cuts1, tb1);
  242.     where {
  243.         (items1,cuts1,tb1)    = EnlargeItemGroup` newItems h items cuts tb nr;
  244.         (newItem1,cuts2)    = CheckShortcutKey newItem cuts1;
  245.         (itemH, tb2)        = NewMenuElementHandle newItem1 0 tb1;
  246.         (title,macstr)        = MenuElementToMacElement newItem1;
  247.         tb3                    = InsMenuItem h macstr nr tb2;
  248.         tb4                    = SetItem h (nr+1) title tb3;
  249.     };
  250. EnlargeItemGroup` _ _ items cuts tb _ = (items, cuts, tb);
  251.  
  252. MenuElementIsGroupItem :: !(MenuElement s (IOState s)) -> Bool;
  253. MenuElementIsGroupItem (MenuItem _ _ _ _ _)            = True;
  254. MenuElementIsGroupItem (CheckMenuItem _ _ _ _ _ _)    = True;
  255. MenuElementIsGroupItem MenuSeparator                = True;
  256. MenuElementIsGroupItem _                            = False;
  257.     
  258.  
  259. //    Removing MenuItems from MenuItemGroups:
  260.  
  261. RemoveMenuItems    :: ![MenuItemId] !(IOState s) -> IOState s;
  262. RemoveMenuItems [] ioState = ioState;
  263. RemoveMenuItems itemIds ioState
  264.     =    IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  265.     where {
  266.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  267.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  268.         (menus1, tb1)        = RemoveMenusItems itemIds menus tb;
  269.     };
  270.         
  271. RemoveMenusItems :: ![MenuItemId] !(DeviceSystemState s) !Toolbox -> (!DeviceSystemState s,!Toolbox);
  272. RemoveMenusItems itemIds (MenuSystemState (menus, cuts, handle, systemAble)) tb
  273.     =    (MenuSystemState (menus1, cuts1, handle, systemAble), tb1);
  274.     where {
  275.         (menus1, cuts1, tb1) = RemoveMenusItems` itemIds menus cuts tb;
  276.     };
  277.  
  278. RemoveMenusItems` :: ![MenuItemId] ![MenuHandle s] ![Char] !Toolbox
  279.     ->    (![MenuHandle s], ![Char], !Toolbox);
  280. RemoveMenusItems` _  menus=:[]    cuts tb = (menus, cuts, tb);
  281. RemoveMenusItems` [] menus        cuts tb = (menus, cuts, tb);
  282. RemoveMenusItems` itemIds [menu : menus] cuts tb
  283.     =    ([menu1 : menus1], cuts2, tb2);
  284.     where {
  285.         (itemIds1, menu1, cuts1, tb1)    = RemoveMenuItems`  itemIds  menu  cuts tb;
  286.         (menus1, cuts2, tb2)            = RemoveMenusItems` itemIds1 menus cuts1 tb1;
  287.     };
  288.  
  289. RemoveMenuItems` ::  ![MenuItemId] !(MenuHandle s) ![Char] !Toolbox
  290.                 ->    (![MenuItemId],! MenuHandle s, ![Char],!Toolbox);
  291. RemoveMenuItems` itemIds (PullDownHandle h id mac_id able items) cuts tb
  292.     =    (itemIds1, PullDownHandle h id mac_id able items1, cuts1, tb1);
  293.     where {
  294.         (itemIds1, items1, cuts1, tb1) = RemoveFromGroupItems itemIds h items cuts tb 1;
  295.     };
  296.  
  297. RemoveFromGroupItems ::  ![MenuItemId] !MacMenuHandle ![MenuHandle s] ![Char] !Toolbox !Int
  298.     ->    (![MenuItemId],![MenuHandle s],![Char],!Toolbox);
  299. RemoveFromGroupItems itemIds  h done=:[] cuts tb nr = (itemIds, done,  cuts, tb);
  300. RemoveFromGroupItems done=:[] h items    cuts tb nr = (done,    items, cuts, tb);
  301. RemoveFromGroupItems itemIds h [MenuItemGroupHandle id items : hs] cuts tb nr
  302.     =    (itemIds2, [MenuItemGroupHandle id items1 : hs1], cuts2, tb2);
  303.     where {
  304.         (itemIds1, items1, cuts1, tb1)    = RemoveGroupItems        itemIds  h items cuts  tb  nr;
  305.         (itemIds2, hs1,    cuts2, tb2)    = RemoveFromGroupItems    itemIds1 h hs    cuts1 tb1 nr1;
  306.         nr1                                = nr+Length_new items1;
  307.     };
  308. RemoveFromGroupItems itemIds h [SubMenuItemHandle subH id mac_id items : hs] cuts tb nr
  309.     =    (itemIds2, [SubMenuItemHandle subH id mac_id items1 : hs1], cuts2, tb2);
  310.     where {
  311.         (itemIds1, items1, cuts1, tb1) = RemoveFromGroupItems itemIds subH items cuts tb 1;
  312.         (itemIds2, hs1,    cuts2, tb2) = RemoveFromGroupItems itemIds1 h hs cuts1 tb1 (nr+1);
  313.     };
  314. RemoveFromGroupItems itemIds h [noItemGroup : hs] cuts tb nr
  315.     =    (itemIds1, [noItemGroup : hs1], cuts1, tb1);
  316.     where {
  317.         (itemIds1, hs1, cuts1, tb1) = RemoveFromGroupItems itemIds h hs cuts tb (nr+1);
  318.     };
  319.  
  320. RemoveGroupItems :: ![MenuItemId] !MacMenuHandle ![MenuHandle s] ![Char] !Toolbox !Int
  321.     ->    (![MenuItemId],![MenuHandle s],![Char],!Toolbox);
  322. RemoveGroupItems itemIds  h done=:[] cuts tb nr = (itemIds, done,  cuts, tb);
  323. RemoveGroupItems done=:[] h items    cuts tb nr = (done,    items, cuts, tb);
  324. RemoveGroupItems itemIds h [itemH : hs] cuts tb nr
  325. |    isAnIdItem && containsItem    = (itemIds2, hs1, cuts1, DelMenuItem h nr tb1);
  326.                                 = (itemIds2, [itemH : hs1], cuts2, tb1);
  327.     where {
  328.         (isAnIdItem, id)            = MenuHandle_MenuItemId itemH;
  329.         (itemIds1, hs1, cuts2, tb1)    = RemoveGroupItems itemIds h hs cuts tb (nr+1);
  330.         (containsItem, itemIds2)    = RemoveCheckInt itemIds1 id;
  331.         cuts1                        = DeleteKey cuts (MenuHandle_ShortcutKey itemH);
  332.     };
  333.  
  334. DeleteKey :: ![Char] !Char -> [Char];
  335. DeleteKey [c : cs] c`
  336. |    c == c`    = cs;
  337.                 = [c : DeleteKey cs c`];
  338. DeleteKey cs c` = cs;
  339.  
  340.  
  341. //    Removing MenuItems from MenuItemGroups by index (counting from 1):
  342.  
  343. RemoveMenuGroupItems :: !MenuItemGroupId ![Int] !(IOState s) -> IOState s;
  344. RemoveMenuGroupItems _ [] ioState = ioState;
  345. RemoveMenuGroupItems gId itemInds ioState
  346.     =     IOStateSetDevice (IOStateSetToolbox (DrawMenuBar tb1) ioState2) menus1;
  347.     where {
  348.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  349.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  350.         (menus1, tb1)        = RemoveMenusGroupItems gId itemInds menus tb;
  351.     };
  352.         
  353. RemoveMenusGroupItems :: !MenuItemGroupId ![Int] !(DeviceSystemState s) !Toolbox
  354.     ->    (!DeviceSystemState s, !Toolbox);
  355. RemoveMenusGroupItems gId itemInds (MenuSystemState (menus, cuts, handle, systemAble)) tb
  356.     =    (MenuSystemState (menus1, cuts1, handle, systemAble), tb1);
  357.     where {
  358.         (menus1, cuts1, tb1) = RemoveMenusGroupItems` gId itemInds menus cuts tb;
  359.     };
  360.     
  361. RemoveMenusGroupItems` :: !MenuItemGroupId ![Int]
  362.          ![MenuHandle s] ![Char] !Toolbox
  363.     ->    (![MenuHandle s],![Char],!Toolbox);
  364. RemoveMenusGroupItems` gId itemInds [menu : menus] cuts tb
  365. |    removed    = ([menu1 : menus ], cuts1, tb1);
  366.             = ([menu  : menus1], cuts2, tb2);
  367.     where {
  368.         (removed,menu1,cuts1,tb1)    = RemoveMenuGroupItems`  gId itemInds menu  cuts tb;
  369.         (menus1, cuts2, tb2)        = RemoveMenusGroupItems` gId itemInds menus cuts tb1;
  370.     };
  371. RemoveMenusGroupItems` _ _ menus cuts tb = (menus, cuts, tb);
  372.     
  373. RemoveMenuGroupItems` :: !MenuItemGroupId ![Int] !(MenuHandle s) ![Char] !Toolbox
  374.     ->    (!Bool, !MenuHandle s, ![Char], !Toolbox);
  375. RemoveMenuGroupItems` gId itemInds menu=:(PullDownHandle h id mac_id able items) cuts tb
  376. |    removed    = (True,  PullDownHandle h id mac_id able items`, cuts`, tb`);
  377.             = (False, menu, cuts, tb`);
  378.     where {
  379.         (removed,items`,cuts`,tb`) = RemoveFromMenuGroupItems gId itemInds h items cuts tb 1;
  380.     };
  381.     
  382. RemoveFromMenuGroupItems :: !MenuItemGroupId ![Int] !MacMenuHandle
  383.                 ![MenuHandle s] ![Char] !Toolbox !Int
  384.     ->    (!Bool, ![MenuHandle s],![Char],!Toolbox);
  385. RemoveFromMenuGroupItems gId itemInds h [item=:MenuItemGroupHandle id items : hs] cuts tb nr
  386. |    gId == id    = (True,    [MenuItemGroupHandle id items1 : hs], cuts1, tb1);
  387.                 = (removed,    [item : hs1], cuts2, tb2);
  388.     where {
  389.         (_,          items1, cuts1, tb1)    = RemoveGroupItems itemIds h items cuts tb nr;
  390.         (removed, hs1,    cuts2, tb2)    = RemoveFromMenuGroupItems gId itemInds h hs cuts tb1 nr1;
  391.         itemIds                            = ItemIndicesToItemIds 1 itemInds items;
  392.         nr1                                = nr+Length_new items;
  393.     };
  394. RemoveFromMenuGroupItems gId itemInds h [item=:SubMenuItemHandle subH id mId items : hs] cuts tb nr
  395. |    subRemoved    = (True,    [SubMenuItemHandle subH id mId items1 : hs], cuts1, tb1);
  396.                 = (removed,    [item : hs1], cuts2, tb2);
  397.     where {
  398.         (subRemoved,items1,cuts1,tb1) = RemoveFromMenuGroupItems gId itemInds subH items cuts tb 1;
  399.         (removed, hs1, cuts2, tb2)      = RemoveFromMenuGroupItems gId itemInds h hs cuts tb1 (inc nr);
  400.     };
  401. RemoveFromMenuGroupItems gId itemInds h [noItemGroup : hs] cuts tb nr
  402.     =    (removed, [noItemGroup : hs1], cuts1, tb1);
  403.     where {
  404.         (removed, hs1, cuts1, tb1) = RemoveFromMenuGroupItems gId itemInds h hs cuts tb (nr+1);
  405.     };
  406. RemoveFromMenuGroupItems _ _ _ done cuts tb _ = (False, done, cuts, tb);
  407.  
  408. ItemIndicesToItemIds :: !Int ![Int] ![MenuHandle s] -> [MenuItemId];
  409. ItemIndicesToItemIds index indices [item : items]
  410. |    contains    = [id : ids];
  411.                 = ids;
  412.     where {
  413.         (contains, indices`)= RemoveCheckInt indices index;
  414.         (_,id)                = MenuHandle_MenuItemId item;
  415.         ids                    = ItemIndicesToItemIds (index+1) indices` items;
  416.     };
  417. ItemIndicesToItemIds _ _ _ = [];
  418.  
  419.     
  420. /*    SelectMenuRadioItem marks the RadioItem and unmarks the currently marked
  421.     RadioItem of the MenuRadioItems it belongs to.
  422. */
  423.  
  424. SelectMenuRadioItem :: !MenuItemId !(IOState s) -> IOState s;
  425. SelectMenuRadioItem itemId ioState
  426.     =    IOStateSetDevice (IOStateSetToolbox tb1 ioState2) menus1;
  427.     where {
  428.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  429.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  430.         (menus1, tb1)        = MenusSelectRadioItem itemId menus tb;
  431.     };
  432.  
  433. MenusSelectRadioItem :: !MenuItemId !(DeviceSystemState s) !Toolbox
  434.     ->    (!DeviceSystemState s, !Toolbox);
  435. MenusSelectRadioItem itemId (MenuSystemState (menus, cuts, handle, systemAble)) tb
  436.     =    (MenuSystemState (menus1, cuts, handle, systemAble), tb1);
  437.     where {
  438.         (menus1,tb1) = MenusSelectRadioItem` itemId menus tb;
  439.     };
  440.  
  441. MenusSelectRadioItem` :: !MenuItemId ![MenuHandle s] !Toolbox -> (![MenuHandle s], !Toolbox);
  442. MenusSelectRadioItem` itemId [menu=:PullDownHandle h id mac_id able items : menus] tb
  443. |    selected    = ([PullDownHandle h id mac_id able items1 : menus], tb1);
  444.                 = ([menu : menus1], tb2);
  445.     where {
  446.         (selected, items1, tb1)    = MenuSelectRadioItem h itemId items tb 1;
  447.         (menus1, tb2)            = MenusSelectRadioItem` itemId menus tb1;
  448.     };
  449. MenusSelectRadioItem` _ menus tb = (menus, tb);
  450.  
  451. MenuSelectRadioItem :: !MacMenuHandle !MenuItemId ![MenuHandle s] !Toolbox !Int
  452.     ->    (!Bool, ![MenuHandle s], !Toolbox);
  453. MenuSelectRadioItem h itemId [item=:MenuRadioItemsHandle radioItems : items] tb nr
  454. |    ContainsInt allIds itemId    = (True,    [item : items ], tb1);
  455.                                 = (changed, [item : items1], tb2);
  456.     where {
  457.         tb1                        = MenuRadioItemsSelectRadioItem h itemId radioItems tb nr;
  458.         allIds                    = MenuElementHandlesToIds radioItems;
  459.         (changed, items1, tb2)    = MenuSelectRadioItem h itemId items tb (nr+Length_new radioItems);
  460.     };
  461. MenuSelectRadioItem h itemId [item=:SubMenuItemHandle subH id mId subItems : items] tb nr
  462. |    selected    = (True,    [SubMenuItemHandle subH id mId subItems1 : items], tb1);
  463.                 = (changed, [item : items1], tb2);
  464.     where {
  465.         (selected, subItems1, tb1) = MenuSelectRadioItem subH itemId subItems tb 1;
  466.         (changed,  items1,    tb2) = MenuSelectRadioItem h itemId items tb1 (nr+1);
  467.     };
  468. MenuSelectRadioItem h itemId [item : items] tb nr
  469.     =    (changed, [item : items1], tb1);
  470.     where {
  471.         (changed, items1, tb1) = MenuSelectRadioItem h itemId items tb (nr+1);
  472.     };
  473. MenuSelectRadioItem _ _ items tb _ = (False, items, tb);
  474.  
  475. MenuRadioItemsSelectRadioItem :: !MacMenuHandle !MenuItemId ![MenuHandle s] !Toolbox !Int
  476.     -> Toolbox;
  477. MenuRadioItemsSelectRadioItem h itemId [item=:CheckMenuItemHandle id _ _ : items] tb nr
  478.     =    MenuRadioItemsSelectRadioItem h itemId items tb1 (nr+1);
  479.     where {
  480.         tb1 = CheckItem h nr (itemId == id) tb;
  481.     };
  482. MenuRadioItemsSelectRadioItem _ _ _ tb _ = tb;
  483.  
  484. MenuElementHandlesToIds :: ![MenuHandle s] -> [MenuItemId];
  485. MenuElementHandlesToIds [CheckMenuItemHandle id _ _ : hs] = [id : MenuElementHandlesToIds hs];
  486. MenuElementHandlesToIds [_ : hs]    = MenuElementHandlesToIds hs;
  487. MenuElementHandlesToIds _            = [];
  488.  
  489.  
  490. //    Changing the attributes of MenuItems:
  491.  
  492. ::    DeltaItemHandle    *s :== (MenuHandle s)    -> MacMenuHandle
  493.                                             -> Int
  494.                                             -> Toolbox
  495.                                             -> (MenuHandle s, !Toolbox);
  496. ::    ItemChange        *s :== (!MenuItemId, !DeltaItemHandle s);
  497.  
  498.  
  499. //    Enabling and Disabling of MenuItems:
  500.  
  501. EnableMenuItems    :: ![MenuItemId] !(IOState s) -> IOState s;
  502. EnableMenuItems itemIds ioState = ChangeMenuItems (Map (SelectionChange Able) itemIds) ioState;
  503.  
  504. DisableMenuItems :: ![MenuItemId] !(IOState s) -> IOState s;
  505. DisableMenuItems itemIds ioState = ChangeMenuItems (Map (SelectionChange Unable) itemIds) ioState;
  506.  
  507. SelectionChange :: SelectState !MenuItemId -> ItemChange s;
  508. SelectionChange ability id = (id, SetItemAbility ability);
  509.  
  510. SetItemAbility :: !SelectState !(MenuHandle s) !MacMenuHandle !Int !Toolbox
  511.     ->    (!MenuHandle s,!Toolbox);
  512. SetItemAbility ability item=:(SubMenuItemHandle subH _ _ _) _ _ tb
  513. |    Enabled ability    = (item, EnableItem  subH 0 tb);
  514.                     = (item, DisableItem subH 0 tb);
  515. SetItemAbility ability item h nr tb
  516. |    Enabled ability    = (item, EnableItem  h nr tb);
  517.                     = (item, DisableItem h nr tb);
  518.  
  519.  
  520. //    Marking and UnMarking of MenuItems:
  521.  
  522. MarkMenuItems :: ![MenuItemId] !(IOState s) -> IOState s;
  523. MarkMenuItems itemIds ioState = ChangeMenuItems (Map (MarkChange Mark) itemIds) ioState;
  524.  
  525. UnmarkMenuItems    :: ![MenuItemId] !(IOState s) -> IOState s;
  526. UnmarkMenuItems itemIds ioState = ChangeMenuItems (Map (MarkChange NoMark) itemIds) ioState;
  527.  
  528. MarkChange :: !MarkState !MenuItemId -> ItemChange s;
  529. MarkChange mark id = (id, SetItemMark mark);
  530.  
  531. SetItemMark :: !MarkState !(MenuHandle s) !MacMenuHandle !Int !Toolbox -> (!MenuHandle s, !Toolbox);
  532. SetItemMark mark item=:(CheckMenuItemHandle id c f) h nr tb
  533.     =    (item, CheckItem h nr (Checked mark) tb);
  534. SetItemMark _ item _ _ tb = (item, tb);
  535.  
  536.  
  537. //    Changing the ItemTitle of MenuItems:
  538.  
  539. ChangeMenuItemTitles :: ![(MenuItemId, ItemTitle)] !(IOState s) -> IOState s;
  540. ChangeMenuItemTitles ids_titles ioState = ChangeMenuItems (Map TitleChange ids_titles) ioState;
  541.  
  542. TitleChange :: !(MenuItemId, ItemTitle) -> ItemChange s;
  543. TitleChange (id, title) = (id, SetItemTitle title);
  544.  
  545. SetItemTitle :: !ItemTitle !(MenuHandle s) !MacMenuHandle !Int !Toolbox -> (!MenuHandle s, !Toolbox);
  546. SetItemTitle title item h nr tb = (item, SetItem h nr title tb);
  547.  
  548.  
  549. //    Changing the MenuFunction of MenuItems:
  550.  
  551. ChangeMenuItemFunctions :: ![(MenuItemId, MenuFunction s (IOState s))] !(IOState s) -> IOState s;
  552. ChangeMenuItemFunctions ids_fs ioState = ChangeMenuItems (Map FunctionChange ids_fs) ioState;
  553.  
  554. FunctionChange :: !(MenuItemId, MenuFunction s (IOState s)) -> ItemChange s;
  555. FunctionChange (id, f) = (id, SetItemFunction f);
  556.  
  557. SetItemFunction :: !(MenuFunction s (IOState s)) !(MenuHandle s) !MacMenuHandle !Int !Toolbox
  558.     ->    (!MenuHandle s, !Toolbox);
  559. SetItemFunction f` (MenuItemHandle        id c _) h nr tb    = (MenuItemHandle        id c f`, tb);
  560. SetItemFunction f` (CheckMenuItemHandle    id c _) h nr tb    = (CheckMenuItemHandle    id c f`, tb);
  561. SetItemFunction _  item                            _ _  tb    = (item, tb);
  562.  
  563.  
  564. //    Now do it!
  565.  
  566. ChangeMenuItems :: ![ItemChange s] !(IOState s) -> IOState s;
  567. ChangeMenuItems [] ioState = ioState;
  568. ChangeMenuItems changes ioState
  569.     =    IOStateSetDevice (IOStateSetToolbox tb1 ioState2) menus1;
  570.     where {
  571.         (menus,    ioState1)    = IOStateGetDevice ioState MenuDevice;
  572.         (tb,    ioState2)    = IOStateGetToolbox ioState1;
  573.         (menus1, tb1)        = SetMenusItems changes menus tb;
  574.     };
  575.  
  576. SetMenusItems :: ![ItemChange s] !(DeviceSystemState s) !Toolbox -> (!DeviceSystemState s, !Toolbox);
  577. SetMenusItems changes (MenuSystemState (menus, cuts, handle, systemAble)) tb
  578.     =    (MenuSystemState (menus1, cuts, handle, systemAble), tb1);
  579.     where {
  580.         (menus1,tb1) = SetMenusItems` changes menus tb;
  581.     };
  582.  
  583. SetMenusItems` :: ![ItemChange s] ![MenuHandle s] !Toolbox -> (![MenuHandle s], !Toolbox);
  584. SetMenusItems` changes [PullDownHandle h id mId able items : menus] tb
  585.     =    ([PullDownHandle h id mId able items1 : menus1], tb2);
  586.     where {
  587.         (items1, tb1) = SetMenuItems changes items h tb 1;
  588.         (menus1, tb2) = SetMenusItems` changes menus tb1;
  589.     };
  590. SetMenusItems` _ menus tb = (menus, tb);
  591.  
  592. SetMenuItems :: ![ItemChange s] ![MenuHandle s] !MacMenuHandle !Toolbox !Int
  593.     ->    (![MenuHandle s], !Toolbox);
  594. SetMenuItems [] items h tb nr = (items, tb);
  595. SetMenuItems changes [item=:MenuItemHandle id c f : items] h tb nr
  596.     | anItem
  597.         = ([item1 : items1], tb2);
  598.         with {
  599.             (item1, tb2)            = change item h nr tb1;
  600.         }
  601.         = ([item  : items1], tb1);
  602.     where {
  603.         (anItem, change, changes`)    = ItemChanges changes id;
  604.         (items1,tb1)                = SetMenuItems changes` items h tb (inc nr);
  605.     };
  606. SetMenuItems changes [item=:CheckMenuItemHandle id c f : items] h tb nr
  607. |    anItem    = ([item1 : items1], tb2);
  608.             = ([item  : items1], tb1);
  609.     where {
  610.         (anItem, change, changes`)    = ItemChanges changes id;
  611.         (item1, tb2)                = change item h nr tb1;
  612.         (items1,tb1)                = SetMenuItems changes` items h tb (nr+1);
  613.     };
  614. SetMenuItems changes [MenuItemGroupHandle id gItems : items] h tb nr
  615.     =    ([MenuItemGroupHandle id gItems1 : items1], tb2);
  616.     where {
  617.         (gItems1,tb1)    = SetMenuItems changes gItems h tb nr;
  618.         (items1, tb2)    = SetMenuItems changes items h tb1 nr1;
  619.         nr1                = nr+Length_new gItems;
  620.     };
  621. SetMenuItems changes [item=:SubMenuItemHandle subH id mId subItems : items] h tb nr
  622. |    anItem    = ([item2 : items1], tb3);
  623.             = ([item1 : items1], tb3);
  624.     where {
  625.         (anItem, change, changes`)    = ItemChanges changes id;
  626.         (subItems1, tb1)            = SetMenuItems changes subItems subH tb 1;
  627.         item1                        = SubMenuItemHandle subH id mId subItems1;
  628.         (item2, tb2)                = change item1 h nr tb1;
  629.         (items1,tb3)                = SetMenuItems changes items h tb2 (nr+1);
  630.     };
  631. SetMenuItems changes [MenuRadioItemsHandle radioItems : items] h tb nr
  632.     =    ([MenuRadioItemsHandle radioItems1 : items1], tb2);
  633.     where {
  634.         (radioItems1, tb1)    = SetMenuRadioItems changes radioItems h tb nr;
  635.         (items1, tb2)        = SetMenuItems changes items h tb1 nr1;
  636.         nr1                    = nr+Length_new radioItems;
  637.     };
  638. SetMenuItems changes [item : items] h tb nr  
  639.     =    ([item : items1], tb1);
  640.     where {
  641.         (items1, tb1) = SetMenuItems changes items h tb (nr+1);
  642.     };
  643. SetMenuItems _ items _ tb _ = (items, tb);
  644.  
  645. SetMenuRadioItems :: ![ItemChange s] ![MenuHandle s] !MacMenuHandle !Toolbox !Int
  646.     ->    (![MenuHandle s], !Toolbox);
  647. SetMenuRadioItems [] checks _ tb _ = (checks, tb);
  648. SetMenuRadioItems changes [check=:CheckMenuItemHandle id c f : checks] h tb nr
  649. |    anItem    = ([check1 : checks1], tb2);
  650.             = ([check  : checks1], tb1);
  651.     where {
  652.         (anItem, change, changes`)    = ItemChanges changes id;
  653.         (check1, tb2)                = change check h nr tb1;
  654.         (checks1,tb1)                = SetMenuRadioItems changes` checks h tb (nr+1);
  655.     };
  656. SetMenuRadioItems _ checks _ tb _ = (checks, tb);
  657.  
  658. ItemChanges :: ![ItemChange s] !MenuItemId -> (!Bool, !DeltaItemHandle s, ![ItemChange s]);
  659. ItemChanges [change=:(itemId, dItem) : changes] id
  660. |    itemId == id    = (True, dItem, changes);
  661.                     = (b, change`, [change : changes`]);
  662.     where {
  663.         (b, change`, changes`) = ItemChanges changes id;
  664.     };
  665. ItemChanges changes _ = (False, NoChange, changes);
  666.  
  667. NoChange :: (MenuHandle s) MacMenuHandle Int Toolbox -> (MenuHandle s, Toolbox);
  668. NoChange h _ _ tb = (h, tb);
  669.